package net.edu_soft.ec.asset.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import net.edu_soft.ec.asset.constant.EduConstant;
import net.edu_soft.ec.asset.mapper.ProductMapper;
import net.edu_soft.ec.asset.pojo.*;
import net.edu_soft.ec.asset.pojo.bo.ProductBO;
import net.edu_soft.ec.asset.pojo.vo.ProductVO;
import net.edu_soft.ec.asset.pojo.vo.SchoolVO;
import net.edu_soft.ec.asset.service.*;
import net.edu_soft.ec.common.exception.OperationException;
import net.edu_soft.ec.common.exception.ParameterException;
import net.edu_soft.ec.common.util.EduCloudsUtils;
import net.edu_soft.ec.common.util.PuingUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

import java.math.BigDecimal;
import java.util.*;

@Service
public class ProductServiceImpl implements ProductService {

    //注入产品mapper
    @Autowired
    private ProductMapper productMapper;

    //注入产品详情业务类
    @Autowired
    private ProductDetailService productDetailService;

    //注入产品扩展业务类
    @Autowired
    private ProExtensionService proExtensionService;

    //注入用户附属业务类
    @Autowired
    private UserAffService userAffService;

    //注入审核业务类
    @Autowired
    private AuditService auditService;

    //注入高校业务类
    @Autowired
    private SchoolService schoolService;

    //注入使用记录业务类
    @Autowired
    private UsageRecordService usageRecordService;

    //注入厂家业务类
    @Autowired
    private FactoryService factoryService;

    @Override
    public Product find(Integer productId) {
        PuingUtil.notNullByZero(productId,"产品id不能为空或者小于等于0");
        return  productMapper.selectByPrimaryKey(productId);
    }

    @Override
    public ProductVO findById(Integer productId) {
        ProductVO productVO = new ProductVO();
        Product product = selProductById(productId);
        if (product!=null) {
            //设置金钱为null
            product.setPrice(null);
            //添加产品
            productVO.setProduct(product);
            //添加产品详情
            productVO.setProductDetail(productDetailService.getDetailByProductId(productId));
            // 查询扩展
            ProExtension extension = proExtensionService.getProExtensionByProductId(productId);
            //添加标签,标签格式必须为json格式，不然会报解析错误
            if(extension.getLabel()!=null&&!"".equals(extension.getLabel())){
                List<Label> labels = JSONObject.parseArray(extension.getLabel(), Label.class);
                productVO.setLabels(labels);
            }
            extension.setLabel(null);
            //添加产品扩展
            productVO.setProExtension(extension);
            //添加高校
            productVO.setSchools(schoolService.selAllByProductId(productId,0,0,false).getList());
        }
        return productVO;
    }

    @Override
    public PageInfo<ProductBO> getProducts(Integer pageNum, Integer pageSize) {
        PuingUtil.notNullByZero(pageNum, "当前页不能小于等于0且为空");
        PuingUtil.notNullByZero(pageSize, "每页数不能小于等于0且为空");

        //得到全部用户的关注的产品
        List<String> productIds = userAffService.getFollows(0);
        if (productIds.size() == 0 || productIds==null) {
            throw new OperationException("没有查询到关注集合");
        }
        //提取出单个id并记录次数
        Map<Integer, Integer> map_i = EduCloudsUtils.frequencyOfListElements(productIds);
        //排序
        Map<Integer, Integer> map_o = EduCloudsUtils.sortByValue(map_i);
        //设置分页
        PageHelper.startPage(pageNum, pageSize);
        //转换
        //得到产品id
        List<Integer> idList = new ArrayList<>(map_o.keySet());
        //得到产品关注度
        List<Integer> followList = new ArrayList<>(map_o.values());
        //批量查询产品
        List<ProductBO> productVOs = productMapper.selectProductByIdList(idList);

        for (ProductBO productBO : productVOs) {
            //设置高校和标签
            setProductBO(productBO);
        }
        //设置关注度 长度为查询出来的id的长度
        for (int i = 0; i < productVOs.size(); i++) {
            productVOs.get(i).setAttention(followList.get(i));
        }
        //封装分页对象
        PageInfo<ProductBO> result = new PageInfo<>(productVOs);
        return result;
    }

    @Override
    public PageInfo<ProductBO> findAllByTypeId(Integer typeId, Integer pageNum, Integer pageSize) {
        //校验
        PuingUtil.notNullByInt("分类查询产品，参数不能为空或小于等于0",typeId,pageNum,pageSize);
        PageHelper.startPage(pageNum,pageSize);
        Map<Integer, String> map = new HashMap<>();
        //得到所有产品的分类
        List<ResultType> resultTypes = productMapper.selAllType();
        //校验
        PuingUtil.notNullByList(resultTypes,"分类查询：没有查询产品分类");
        //添加进map集合
        for (ResultType rt: resultTypes) {
            map.put(rt.getId(), rt.getType());
        }
        //得到提取后产品id集合
        List<Integer> productIds = EduCloudsUtils.existsId(typeId, map);
        //查询产品信息
        //校验
        PuingUtil.notNullByList(productIds,"分类查询：没有查询产品信息");
        List<ProductBO> productBOS = productMapper.selectProductByIdList(productIds);
        //校验
        PuingUtil.notNullByList(productBOS,"分类查询：没有查询产品信息");
        //用产品id集合查询出关注度
        //得到全部用户的关注的产品
        List<String> productIds_user_aff = userAffService.getFollows(0);
        //校验
        PuingUtil.notNullByList(productIds,"分类查询：没有查询到关注集合");
        Map<Integer, Integer> map_i = EduCloudsUtils.frequencyOfListElements(productIds_user_aff);
        //1.1遍历关注度并添加到产品集合中
        for (Map.Entry<Integer,Integer> m1:map_i.entrySet()) {
            //遍历产品
            for (ProductBO product:productBOS) {
                //是否匹配
                if(product.getProductId()==m1.getKey()){
                    //2.匹配产品id填入产品关注度
                    product.setAttention(m1.getValue());
                    continue;
                }
            }
        }
        //查询并添加高校
        for (ProductBO product:productBOS) {
            PageInfo<SchoolVO> schoolVOPageInfo = schoolService.selAllByProductId(product.getProductId(), 0, 0,false);
            product.setSchools(schoolVOPageInfo.getList());
        }
        //查询标签
        for (ProductBO product:productBOS) {
            List<Label> labels = proExtensionService.findLabelById(product.getProductId());
            product.setLabels(labels);
        }
        PageInfo<ProductBO> result = new PageInfo<>(productBOS);
        return result;
    }

    @Override
    public int delProductByIds(Integer isDel, List<Integer> ids) {
        //为0则不删除返回1
        if(isDel==0){
            return 0;
        }
        Product product = new Product();
        for (Integer productId : ids) {
            product = selProductById(productId);
            if (product==null){
               throw new OperationException("根据id： "+productId+" 找不到该对象");
            }
            //设置状态为1 不可用 已删除
            //删除审核记录，设置为不可用
            product.setStatus(EduConstant.STATUS_ONE);
            //执行修改
            int i= productMapper.updateByPrimaryKeySelective(product);
            if(i==0){
                throw new OperationException("删除失败，未知错误");
            }
            //删除审核记录 将id封装为字符串
            auditService.delAuditByIds(String.valueOf(productId),1);
            //删除使用记录
            usageRecordService.del(productId,1);
            // 重置
            product = new Product();
        }
        return 1;
    }

    @Override
    public int saveProduct(ProductVO productVO, Audit audit,String inSchool) {
        if(inSchool!=null&&!"".equals(inSchool)){
            productVO.setSchools(JSONObject.parseArray(inSchool, SchoolVO.class));
        }
        if(productVO ==null){
            throw new ParameterException("参数为空！");
        }
        //查询是否存在
        Product findProduct = selProductByName(productVO.getProduct().getName(), productVO.getProduct().getFactoryId());
        if(findProduct!=null){
            throw new OperationException("已存在该产品！！！");
        }
        //校验数据
        Product product = checkData(productVO.getProduct());
        //添加,mapper中设置添加立即返回主键
        int falg = productMapper.insertSelective(product);
        //设置产品详情中的产品id
        productVO.getProductDetail().setProductId(productVO.getProduct().getProductId());
        //设置产品扩展中的产品id
        productVO.getProExtension().setProductId(productVO.getProduct().getProductId());
        //添加产品详情
        int i = productDetailService.saveDetail(productVO.getProductDetail());
        //添加产品扩展
        int a = proExtensionService.saveProExtension(productVO.getProExtension());
        //添加审核记录
        //查询审核表，审核表中有这条记录且状态为可用则存在
        //设置主体
        audit.setSubjectId(product.getProductId());
        //设置类型
        audit.setType(EduConstant.AUDIT_TYPE_PRODUCT);
        int b = auditService.saveAudit(audit);
        //添加产品与高校关系
        List<SchoolVO> schools = productVO.getSchools();
        if(schools.size()>0&&schools!=null){
            for (SchoolVO school:schools) {
                UsageRecord usageRecord = new UsageRecord();
                //设置产品id
                usageRecord.setProductId(product.getProductId());
                //设置高校id
                usageRecord.setSchoolId(school.getSchoolId());
                //设置高校使用路径
                usageRecord.setUsageUrl(school.getUsageUrl());
                usageRecordService.save(usageRecord);
            }
        }
        //判断并返回
        if(i==1&&a==1&&falg==1&&b==1){
            return 1;
        }
        return 0;
    }

    @Override
    public int updateProduct(ProductVO productVO) {
        if(productVO ==null){
            throw new ParameterException("参数为空！");
        }
        //根据id查询产品是否存在
        if(selProductById(productVO.getProduct().getProductId())==null){
            throw new OperationException("不存在该产品！！！");
        }
        //校验数据
        Product product = checkData(productVO.getProduct());
        //修改产品信息
        int a = productMapper.updateByPrimaryKeySelective(product);
        //修改产品详情
        int b = productDetailService.updateDetail(productVO.getProductDetail());
        //修改产品扩展
        int c = proExtensionService.updateProExtension(productVO.getProExtension());
        //提取产品与高校的关系中高校的id
        List<Integer> schoolIds = new ArrayList<>();
        if(productVO.getSchools().size()>0&&productVO.getSchools()!=null){
        for (SchoolVO schoolVO: productVO.getSchools()) {
            schoolIds.add(schoolVO.getSchoolId());
        }
        //判断是否存在相同的高校id
        EduCloudsUtils.cheakNumbers(schoolIds);
        //修改产品高校关系
        for (SchoolVO schoolVO: productVO.getSchools()) {
            //循环高校提取
            UsageRecord usageRecord = new UsageRecord();
            usageRecord.setProductId(productVO.getProduct().getProductId());
            usageRecord.setSchoolId(schoolVO.getSchoolId());
            usageRecord.setUsageUrl(schoolVO.getUsageUrl());
            usageRecord.setUsageRecordId(schoolVO.getUsageRecordId());
            //执行更新
            usageRecordService.update(usageRecord);
        }}
        if(a==1&&b==1&&c==1){
            return 1;
        }
        return 0;
    }

    @Override
    public PageInfo<ProductBO> findFacPro( String factoryName,Integer condition, Integer pageNum, Integer pageSize) {
        PuingUtil.notNullByInt("产品管理：根据厂家查询产品参数为空或小于等于0",condition,pageNum,pageSize);
        List<ProductBO> productBOS = null;
        // 判断厂家名
        String fName = null;
        if (factoryName != null && !StringUtils.isEmpty(factoryName.trim())) {
            fName = "%"+factoryName.trim()+"%";//去空格拼接模糊%
        }
        PageHelper.startPage(pageNum,pageSize);
        //判断查询
        if(condition==1){
            //1 用户最多
            productBOS = productMapper.selProByUse(fName);
        }else if (condition==2){
            //2 最新收录
            productBOS = productMapper.selProByDate(fName);
        }else {
            throw new ParameterException("产品管理：厂家条件查询参数错误");
        }
        //将高校、标签、添加进产品
        if(productBOS!=null){
            //添加关注数
            setAtt(productBOS);
            //添加标签、高校
            for (ProductBO productBO: productBOS) {
                setProductBO(productBO);
            }
        }
        PageInfo<ProductBO> pageInfo = new PageInfo<>(productBOS);
        return pageInfo;
    }

    @Override
    public PageInfo<ProductBO> finProByDate(Integer condition, Integer pageNum, Integer pageSize) {
        PuingUtil.notNullByInt("产品管理：根据最新产品参数为空或小于等于0",condition,pageNum,pageSize);
        PageHelper.startPage(pageNum,pageSize);
        List<ProductBO> productBOS = new ArrayList<>();
        if(condition==1){
            productBOS = productMapper.selProByDate(null);
        }
        //将高校、标签、添加进产品
        if(productBOS!=null){
            //添加关注数
            setAtt(productBOS);
            //添加标签、高校
            for (ProductBO productBO: productBOS) {
                setProductBO(productBO);
            }
        }
        PageInfo<ProductBO> pageInfo = new PageInfo<>(productBOS);
        return pageInfo;
    }


    private  Product selProductById(Integer productId){
        PuingUtil.notNullByZero(productId,"产品id不能为空或者小于等于0");
        ProductExample example = new ProductExample();
        ProductExample.Criteria criteria = example.createCriteria();
        //状态
        criteria.andStatusEqualTo(EduConstant.STATUS_ZREO);
        //产品id
        criteria.andProductIdEqualTo(productId);
        List<Product> productList = productMapper.selectByExample(example);
        if(productList.size()>0){
            return productList.get(0);
        }
        return null;
    }

    /***
     * 校验数据
     * @param product 产品
     * @return
     */
    private Product checkData(Product product){
        //判断产品id是否存在，存在就是修改，不存在就是添加
        if(product.getProductId()!=null){
            //  添加修改时间
            product.setUpdateDate(new Date());
        }else {
            // 1.8 默认为不可用，需要审核
            product.setStatus(EduConstant.STATUS_ONE);
        }
        //1.校验产品基础信息
            //1.1校验厂家id
        PuingUtil.notNullByZero(product.getFactoryId(),"厂家id不能为空或者小于等于0");
            //1.2校验厂家名
        Assert.hasLength(product.getFactoryName(), "厂家名不能为空");
            //1.3校验产品名
        Assert.hasLength(product.getName(), "产品名称不能为空");
            //1.4校验展示图路径
        Assert.hasLength(product.getUrl(), "展示图路径不能为空");
            //1.5校验产品类型
        Assert.hasLength(product.getProductType(),"产品类型不能为空");
            //1.6校验产品价格
        if(product.getPrice()==null || product.getPrice().compareTo(new BigDecimal("0.00"))<=0){
            throw new ParameterException("价格不能为空或者小于0.00");
        }
            //1.7设置创建时间
        if(product.getCreateDate()==null){
            product.setCreateDate(new Date());
        }
        return product;
    }


    /**
     * 根据产品名称和厂家id查询是否存在该产品
     * @param productName 产品名
     * @param factoryId 厂家id
     * @return 产品信息
     */
    private Product selProductByName(String  productName,Integer factoryId){
        Assert.hasLength(productName,"产品名称不能为空");
        PuingUtil.notNullByZero(factoryId,"厂家id不能为空或者小于等于0");
        ProductExample example = new ProductExample();
        ProductExample.Criteria criteria = example.createCriteria();
        //添加名称
        criteria.andNameEqualTo(productName);
        //添加产厂家id
        criteria.andFactoryIdEqualTo(factoryId);
        //添加状态
        //criteria.andStatusEqualTo(EduConstant.STATUS_ZREO);
        List<Product> products = productMapper.selectByExample(example);
        if(products.size()>0){
            //遍历判断产品状态是否是在用
            for (Product product: products) {
                //有则返回当前产品和id
                if(product.getStatus()==EduConstant.STATUS_ZREO){
                    return product;
                }
                //判断是否存在审核
                Audit audit = auditService.getAuditBySubAndType(product.getProductId(), EduConstant.AUDIT_TYPE_PRODUCT);
                if(audit!=null){
                    throw new OperationException("存在该商品和审核记录");
                }
            }
        }
        //无则返回null
        return null;
    }


    /***
     * 设置产品的高校、标签
     * @param productBO
     * @return
     */
    private void setProductBO(ProductBO productBO){
        if(productBO!=null){
            //根据id查询产品的高校使用记录
            PageInfo<SchoolVO> schoolVOPageInfo = schoolService.selAllByProductId(productBO.getProductId(), 0, 0, false);
            //把查询到的高校放进集合
            productBO.setSchools(schoolVOPageInfo.getList());
            //查询标签
            List<Label> labels = proExtensionService.findLabelById(productBO.getProductId());
            //放进集合
            productBO.setLabels(labels);
        }
    }


    /***
     * 设置产品关注度
     * @param productBOS
     */
    private void setAtt(List<ProductBO> productBOS){
        List<String> productIds_user_aff = userAffService.getFollows(0);
        //校验
        if(productIds_user_aff == null){
            throw new OperationException("产品管理：所有关注为空");
        }
        Map<Integer, Integer> map_i = EduCloudsUtils.frequencyOfListElements(productIds_user_aff);
        //1.1遍历关注度并添加到产品集合中
        for (Map.Entry<Integer,Integer> m1:map_i.entrySet()) {
            //遍历产品
            for (ProductBO product:productBOS) {
                //是否匹配
                if(product.getProductId()==m1.getKey()){
                    //2.匹配产品id填入产品关注度
                    product.setAttention(m1.getValue());
                    continue;
                }
            }
        }
    }
}
